I have sorted it!!!...and also solved my own problem from last Friday at the
same time ...the "keystore" has a password and so does the private key entry.
I really don't think I could have solved this without a book - "Professional
Java Security" by Garms&Somerfield, ISBN 1-861004-25-7

Quote from book "Public keys are encoded using X.509... Private keys are
encoded using PKCS#8 which is standard simply for encoding private keys"

My complete code (including RSA encryption and decryption!!) is now:-

import java.io.FileInputStream;
import java.security.KeyStore;
import java.util.Enumeration;
import java.security.cert.Certificate;
import java.security.Key;
import java.security.spec.PKCS8EncodedKeySpec;
import java.security.spec.X509EncodedKeySpec;
import java.security.KeyFactory;
import java.security.PrivateKey;
import java.security.PublicKey;
import javax.crypto.Cipher;

public class PKCS12 {

  public static void main(String[] args) {

     KeyStore keyStore;
     KeyFactory keyFactory = null;

     try {
        String home = System.getProperty("user.home");
        FileInputStream file_inputstream = new
           FileInputStream(home + "/brian.p12");
        keyStore = KeyStore.getInstance("PKCS12");
        keyStore.load(file_inputstream, "keystorepassword".toCharArray());
        System.out.println("Keystore size " + keyStore.size());
        Enumeration aliases = keyStore.aliases();
        while(aliases.hasMoreElements()) {
           System.out.println(aliases.nextElement());
        }
        Key key=keyStore.getKey("brian", "privatekeypass".toCharArray());
        System.out.println("Key information " + key.getAlgorithm() + " "
                           + key.getFormat());
        PKCS8EncodedKeySpec keySpec = new
             PKCS8EncodedKeySpec(key.getEncoded());
        keyFactory = keyFactory.getInstance("RSA");
        PrivateKey privateKey = keyFactory.generatePrivate(keySpec);

        Certificate cert = keyStore.getCertificate("brian");
        X509EncodedKeySpec keySpec1 = new
            X509EncodedKeySpec(cert.getPublicKey().getEncoded());
        PublicKey publicKey = keyFactory.generatePublic(keySpec1);

        String testString = "A string to be encoded";
       
        Cipher rsaCipher = Cipher.getInstance("RSA/ECB/PKCS1Padding");
        rsaCipher.init(Cipher.ENCRYPT_MODE, privateKey);
        byte[] encodedBytes = rsaCipher.doFinal(testString.getBytes());
        System.out.println("Encoded byte array length = " +
            encodedBytes.length + "\nFirst 20 bytes = ");
        for(int i=0; i<20; i++) {
           System.out.print(encodedBytes[i] + " ");
        }
        System.out.println();

        rsaCipher.init(Cipher.DECRYPT_MODE, publicKey);
        byte[] decodedBytes = rsaCipher.doFinal(encodedBytes);
        String output = new String(decodedBytes);
        System.out.println("String after RSA encryption and decryption = "
           + output);

     } catch (Exception e) {
        System.err.println("Exception:- " + e);
     }
  }
}

Output (for me) is:-

Keystore size 1
brian
Key information RSA PKCS#8
Encoded byte array length = 128
First 20 bytes =
-63 20 -54 -7 90 40 -91 55 -37 -49 -38 97 28 89 72 20 -114 -113 -110 100
String after RSA encryption and decryption = A string to be encoded